package org.common.utils;

import java.io.*;
import java.math.BigDecimal;
import java.text.NumberFormat;
import java.util.*;

public class CommonUtils {

    /**
     * 判断String是否合法
     *
     * @return true=不合法
     */
    public static boolean isEmpty(final String string) {
        return null == string || "".equals(string) || "null".equals(string.toLowerCase());
    }

    /**
     * 判断类是否合法
     *
     * @return true=不合法
     */
    public static boolean isEmpty(Class cla) {
        return cla == null;
    }

    /**
     * 判断Long是否合法
     *
     * @return true=不合法
     */
    public static boolean isEmpty(final Long long1) {
        return null == long1 || long1.equals(0L);
    }

    /**
     * 判断Integer是否合法
     *
     * @return true=不合法
     */
    public static boolean isEmpty(final Integer integer) {
        return null == integer || integer.equals(0);
    }

    /**
     * 判断Double是否合法
     *
     * @return true=不合法
     */
    public static boolean isEmpty(final Double double1) {
        return null == double1 || double1.equals(0.0);
    }

    /**
     * 判断Boolean是否合法
     *
     * @return true=不合法
     */
    public static boolean isEmpty(final Boolean boolean1) {
        return null == boolean1;
    }

    /**
     * 判断集合是否空
     *
     * @param collection 集合
     * @return true=空集合
     */
    public static boolean isEmpty(final Collection<?> collection) {
        return null == collection || collection.isEmpty();
    }

    /**
     * 判断Map是否空
     *
     * @param map Map
     * @return true=空Map
     */
    public static boolean isEmpty(final Map<?, ?> map) {
        return null == map || map.isEmpty();
    }

    public static String getPriceStr(final double price) {
        return NumberFormat.getInstance().format(new BigDecimal(price).setScale(2, 4).doubleValue()).replace(",", "");
    }

    /**
     * 字符串去除所有空格
     *
     * @param sValue 值
     * @return 去除空格后的值
     */
    public static String replaceAll(String sValue) {
        if (CommonUtils.isEmpty(sValue)) {
            return "";
        }
        return sValue.replaceAll("\\s*", "");
    }

    /**
     * 屏蔽私隐信息
     *
     * @param sValueType 屏蔽类型
     * @param sValue     原信息
     * @return 屏蔽后的信息
     */
    public static String shieldingInformation(final String sValueType, final String sValue) {
        StringBuilder builder = new StringBuilder(sValue);
        if (isEmpty(sValue)) {
            return builder.toString();
        }
        if ("1".equals(sValueType)) {
            if (sValue.length() == 15) {
                builder.append(sValue, 0, 15).append("****").append(sValue.substring(14));
            } else if (sValue.length() == 18) {
                builder.append(sValue, 0, 13).append("****").append(sValue.substring(17));
            }
        } else if ("2".equals(sValueType)) {
            if (sValue.length() == 11) {
                builder.append(sValue, 0, 7).append("***").append(sValue.substring(10));
            }
        } else if ("3".equals(sValueType)) {
            if (!sValue.contains("-") && sValue.length() >= 7) {
                builder.append(sValue, 0, 5).append("**").append(sValue.substring(6));
            } else if (sValue.contains("-")) {
                if (sValue.substring(sValue.indexOf("-") + 1).length() >= 7) {
                    final int sStartIndex = sValue.indexOf("-") + 6;
                    builder.append(sValue, 0, sStartIndex).append("**").append(sValue.substring(sStartIndex + 1));
                }
            }
        } else if ("4".equals(sValueType)) {
            StringBuilder sShielded = new StringBuilder();
            for (int i = 5; i < sValue.length(); ++i) {
                sShielded.append("*");
            }
            if (sValue.length() >= 6) {
                builder.append(sValue, 0, 5).append(sShielded);
            }
        }
        return builder.toString();
    }

    /**
     * 获取UUID
     *
     * @return UUID
     */
    public static String getUUID() {
        return UUID.randomUUID().toString().replace("-", "").toUpperCase();
    }

    /**
     * 将KEY写入文件中
     *
     * @param key      KEY值
     * @param filePath 文件路径
     */
    public static void outputStreamWriter(final String key, final String filePath) {
        try {
            final FileOutputStream fileOutputStream = new FileOutputStream(filePath);
            final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
            outputStreamWriter.write(key);
            outputStreamWriter.flush();
            outputStreamWriter.close();
        } catch (IOException e2) {
            e2.printStackTrace();
        }
    }

    /**
     * 获取KEY
     *
     * @param filePath 文件路径
     * @return KEY
     */
    public static String getKeyFile(String filePath) {
        final File file = new File(filePath);
        final Long length = file.length();
        final byte[] filecontent = new byte[(int) (Object) length];
        String key = "";
        try {
            final FileInputStream fileInputStream = new FileInputStream(file);
            fileInputStream.read(filecontent);
            fileInputStream.close();
            key = new String(filecontent, "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return key;
    }

    /**
     * 获取数组中重复的值和重复的次数
     *
     * @param attr 数组
     * @return 重复的值和重复的次数
     */
    public static Map<Number, Integer> getRepeatArrayValue(Number[] attr) {
        Map<Number, Integer> numMap = new HashMap<>();
        for (Number anAttr : attr) {
            numMap.merge(anAttr, 1, (a, b) -> a + b);
        }
        return numMap;
    }

    /**
     * 获取数组中重复的值和重复的次数
     *
     * @param attr 数组
     * @return 重复的值和重复的次数
     */
    public static Map<Number, Integer> getRepeatArrayValue(String[] attr) {
        Integer[] iAttr = new Integer[attr.length];
        for (int i = 0; i < attr.length; i++) {
            iAttr[i] = Integer.valueOf(attr[i]);
        }
        return getRepeatArrayValue(iAttr);
    }

    /**
     * 获取数组中重复的值和重复的次数
     *
     * @param attr 数组
     * @return 重复的值和重复的次数
     */
    public static Map<Number, Integer> getRepeatArrayValueToDouble(Double[] attr) {
        return getRepeatArrayValue(attr);
    }
}